package solutions.ferpa.ztest.ent;

import java.sql.*;
import java.util.ArrayList;
import br.com.telescope.adsrt.dom.*;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.t2.exception.Severity;

/**
 * API de persistência de dados da entidade REGRA_VARIAVEL_PLANO_EXECUCAO
 * @author Gerado pelo Telescope
 */
public class EntRegraVariavelPlanoExecucao extends Entity {
    
    public final static String ENTITY_NAME = "ZTEST.REGRA_VARIAVEL_PLANO_EXECUCAO";
    public final static String TABLE_NAME = "REGRA_VARIAVEL_PLANO_EXECUCAO";
    
    // <editor-fold defaultstate="collapsed" desc="Contrutores e inicializacao">
    /**
     * Construtores
     */
    public EntRegraVariavelPlanoExecucao() {
        super();
        initialize();
    }
    
    public EntRegraVariavelPlanoExecucao(BaseRuntime ctx) {
        super();
        initialize(ctx);
    }
    
    @Override
    public String getPrimaryKeyColumn() {
        return "ID";
    }
    
    @Override
    public void initialize(BaseRuntime ctx) {
        super.initialize(ctx);
        initialize();
    }
    
    public void initialize() {
        aId = new DomId(this,"ID", "Id"); 
        aId.setRequired(true);
        oId = new DomId();
        aVariavelAplicativoId = new DomId(this,"VARIAVEL_APLICATIVO_ID", "Variável do aplicativo"); 
        aVariavelAplicativoId.setRequired(true);
        oVariavelAplicativoId = new DomId();
        aPlanoExecucaoId = new DomId(this,"PLANO_EXECUCAO_ID", "Plano de execução"); 
        aPlanoExecucaoId.setRequired(true);
        oPlanoExecucaoId = new DomId();
        aPontoPlanoExecucaoId = new DomId(this,"PONTO_PLANO_EXECUCAO_ID", "Ponto do plano de execução"); 
        oPontoPlanoExecucaoId = new DomId();
        aNumeroIteracao = new DomInteger(this,"NUMERO_ITERACAO", "Número da iteração"); 
        aNumeroIteracao.setRequired(true);
        aNumeroIteracao.setDefaultValue("1");
        oNumeroIteracao = new DomInteger();
        aProcessoAplicativoId = new DomId(this,"PROCESSO_APLICATIVO_ID", "Processo do aplicativo"); 
        oProcessoAplicativoId = new DomId();
        aFormulaValorEsperadoId = new DomId(this,"FORMULA_VALOR_ESPERADO_ID", "Fórmula (valor esperado)"); 
        oFormulaValorEsperadoId = new DomId();
        aValorDefault = new DomText(this,"VALOR_DEFAULT", "Valor default"); 
        oValorDefault = new DomText();
        aListaValores = new DomProperties(this,"LISTA_VALORES", "Lista de valores"); 
        oListaValores = new DomProperties();
        aValorMinimoEsperado = new DomText(this,"VALOR_MINIMO_ESPERADO", "Valor mínimo esperado"); 
        oValorMinimoEsperado = new DomText();
        aValorMaximoEsperado = new DomText(this,"VALOR_MAXIMO_ESPERADO", "Valor máximo esperado"); 
        oValorMaximoEsperado = new DomText();
        aFormulaValorMinimoId = new DomId(this,"FORMULA_VALOR_MINIMO_ID", "Fórmula (valor mínimo esperado)"); 
        oFormulaValorMinimoId = new DomId();
        aFormulaValorMaximoId = new DomId(this,"FORMULA_VALOR_MAXIMO_ID", "Fórmula (valor máximo esperado)"); 
        oFormulaValorMaximoId = new DomId();
        ressetModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributos da entidade">
    
    // Id
    private DomId aId;
    private DomId oId;
    
    // Variável do aplicativo
    private DomId aVariavelAplicativoId;
    private DomId oVariavelAplicativoId;
    
    // Plano de execução
    private DomId aPlanoExecucaoId;
    private DomId oPlanoExecucaoId;
    
    // Ponto do plano de execução
    private DomId aPontoPlanoExecucaoId;
    private DomId oPontoPlanoExecucaoId;
    
    // Número da iteração
    private DomInteger aNumeroIteracao;
    private DomInteger oNumeroIteracao;
    
    // Processo do aplicativo
    private DomId aProcessoAplicativoId;
    private DomId oProcessoAplicativoId;
    
    // Fórmula (valor esperado)
    private DomId aFormulaValorEsperadoId;
    private DomId oFormulaValorEsperadoId;
    
    // Valor default
    private DomText aValorDefault;
    private DomText oValorDefault;
    
    // Lista de valores
    private DomProperties aListaValores;
    private DomProperties oListaValores;
    
    // Valor mínimo esperado
    private DomText aValorMinimoEsperado;
    private DomText oValorMinimoEsperado;
    
    // Valor máximo esperado
    private DomText aValorMaximoEsperado;
    private DomText oValorMaximoEsperado;
    
    // Fórmula (valor mínimo esperado)
    private DomId aFormulaValorMinimoId;
    private DomId oFormulaValorMinimoId;
    
    // Fórmula (valor máximo esperado)
    private DomId aFormulaValorMaximoId;
    private DomId oFormulaValorMaximoId;
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ID">
    
    public EntRegraVariavelPlanoExecucao id(Long value) {
        setId(value);
        return this;
    }
    
    public void setId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyId();
        } else {
            aId.setValue(value.getValue());
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(String value) {
        if (value == null) {
            nullifyId();
        } else {
            aId.setValue(value);
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(Long value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void setId(Object value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyId() {
        if (!aId.isNull()) {
            aId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getId() {
        return aId;
    }
    
    public DomId oldId() {
        return oId;
    }
    
    public Long valueOfId() {
        return aId.getValue();
    }
    
    public boolean isIdModified() {
        return aId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo VARIAVEL_APLICATIVO_ID">
    
    public EntRegraVariavelPlanoExecucao variavelAplicativoId(Long value) {
        setVariavelAplicativoId(value);
        return this;
    }
    
    public void setVariavelAplicativoId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyVariavelAplicativoId();
        } else {
            aVariavelAplicativoId.setValue(value.getValue());
            if (aVariavelAplicativoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setVariavelAplicativoId(String value) {
        if (value == null) {
            nullifyVariavelAplicativoId();
        } else {
            aVariavelAplicativoId.setValue(value);
            if (aVariavelAplicativoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setVariavelAplicativoId(Long value) {
        aVariavelAplicativoId.setValue(value);
        if (aVariavelAplicativoId.isModified()) {
            setModified(true);
        }
    }
    
    public void setVariavelAplicativoId(Object value) {
        aVariavelAplicativoId.setValue(value);
        if (aVariavelAplicativoId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyVariavelAplicativoId() {
        if (!aVariavelAplicativoId.isNull()) {
            aVariavelAplicativoId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getVariavelAplicativoId() {
        return aVariavelAplicativoId;
    }
    
    public DomId oldVariavelAplicativoId() {
        return oVariavelAplicativoId;
    }
    
    public Long valueOfVariavelAplicativoId() {
        return aVariavelAplicativoId.getValue();
    }
    
    public boolean isVariavelAplicativoIdModified() {
        return aVariavelAplicativoId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo PLANO_EXECUCAO_ID">
    
    public EntRegraVariavelPlanoExecucao planoExecucaoId(Long value) {
        setPlanoExecucaoId(value);
        return this;
    }
    
    public void setPlanoExecucaoId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyPlanoExecucaoId();
        } else {
            aPlanoExecucaoId.setValue(value.getValue());
            if (aPlanoExecucaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPlanoExecucaoId(String value) {
        if (value == null) {
            nullifyPlanoExecucaoId();
        } else {
            aPlanoExecucaoId.setValue(value);
            if (aPlanoExecucaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPlanoExecucaoId(Long value) {
        aPlanoExecucaoId.setValue(value);
        if (aPlanoExecucaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void setPlanoExecucaoId(Object value) {
        aPlanoExecucaoId.setValue(value);
        if (aPlanoExecucaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyPlanoExecucaoId() {
        if (!aPlanoExecucaoId.isNull()) {
            aPlanoExecucaoId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getPlanoExecucaoId() {
        return aPlanoExecucaoId;
    }
    
    public DomId oldPlanoExecucaoId() {
        return oPlanoExecucaoId;
    }
    
    public Long valueOfPlanoExecucaoId() {
        return aPlanoExecucaoId.getValue();
    }
    
    public boolean isPlanoExecucaoIdModified() {
        return aPlanoExecucaoId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo PONTO_PLANO_EXECUCAO_ID">
    
    public EntRegraVariavelPlanoExecucao pontoPlanoExecucaoId(Long value) {
        setPontoPlanoExecucaoId(value);
        return this;
    }
    
    public void setPontoPlanoExecucaoId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyPontoPlanoExecucaoId();
        } else {
            aPontoPlanoExecucaoId.setValue(value.getValue());
            if (aPontoPlanoExecucaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPontoPlanoExecucaoId(String value) {
        if (value == null) {
            nullifyPontoPlanoExecucaoId();
        } else {
            aPontoPlanoExecucaoId.setValue(value);
            if (aPontoPlanoExecucaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPontoPlanoExecucaoId(Long value) {
        aPontoPlanoExecucaoId.setValue(value);
        if (aPontoPlanoExecucaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void setPontoPlanoExecucaoId(Object value) {
        aPontoPlanoExecucaoId.setValue(value);
        if (aPontoPlanoExecucaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyPontoPlanoExecucaoId() {
        if (!aPontoPlanoExecucaoId.isNull()) {
            aPontoPlanoExecucaoId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getPontoPlanoExecucaoId() {
        return aPontoPlanoExecucaoId;
    }
    
    public DomId oldPontoPlanoExecucaoId() {
        return oPontoPlanoExecucaoId;
    }
    
    public Long valueOfPontoPlanoExecucaoId() {
        return aPontoPlanoExecucaoId.getValue();
    }
    
    public boolean isPontoPlanoExecucaoIdModified() {
        return aPontoPlanoExecucaoId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo NUMERO_ITERACAO">
    
    public EntRegraVariavelPlanoExecucao numeroIteracao(Integer value) {
        setNumeroIteracao(value);
        return this;
    }
    
    public void setNumeroIteracao(DomInteger value) {
        if (value == null || value.isNull()) {
            nullifyNumeroIteracao();
        } else {
            aNumeroIteracao.setValue(value.getValue());
            if (aNumeroIteracao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNumeroIteracao(String value) {
        if (value == null) {
            nullifyNumeroIteracao();
        } else {
            aNumeroIteracao.setValue(value);
            if (aNumeroIteracao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNumeroIteracao(Integer value) {
        aNumeroIteracao.setValue(value);
        if (aNumeroIteracao.isModified()) {
            setModified(true);
        }
    }
    
    public void setNumeroIteracao(Object value) {
        aNumeroIteracao.setValue(value);
        if (aNumeroIteracao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyNumeroIteracao() {
        if (!aNumeroIteracao.isNull()) {
            aNumeroIteracao.setNull(true);
            setModified(true);
        }
    }
    
    public DomInteger getNumeroIteracao() {
        return aNumeroIteracao;
    }
    
    public DomInteger oldNumeroIteracao() {
        return oNumeroIteracao;
    }
    
    public Integer valueOfNumeroIteracao() {
        return aNumeroIteracao.getValue();
    }
    
    public boolean isNumeroIteracaoModified() {
        return aNumeroIteracao.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo PROCESSO_APLICATIVO_ID">
    
    public EntRegraVariavelPlanoExecucao processoAplicativoId(Long value) {
        setProcessoAplicativoId(value);
        return this;
    }
    
    public void setProcessoAplicativoId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyProcessoAplicativoId();
        } else {
            aProcessoAplicativoId.setValue(value.getValue());
            if (aProcessoAplicativoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setProcessoAplicativoId(String value) {
        if (value == null) {
            nullifyProcessoAplicativoId();
        } else {
            aProcessoAplicativoId.setValue(value);
            if (aProcessoAplicativoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setProcessoAplicativoId(Long value) {
        aProcessoAplicativoId.setValue(value);
        if (aProcessoAplicativoId.isModified()) {
            setModified(true);
        }
    }
    
    public void setProcessoAplicativoId(Object value) {
        aProcessoAplicativoId.setValue(value);
        if (aProcessoAplicativoId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyProcessoAplicativoId() {
        if (!aProcessoAplicativoId.isNull()) {
            aProcessoAplicativoId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getProcessoAplicativoId() {
        return aProcessoAplicativoId;
    }
    
    public DomId oldProcessoAplicativoId() {
        return oProcessoAplicativoId;
    }
    
    public Long valueOfProcessoAplicativoId() {
        return aProcessoAplicativoId.getValue();
    }
    
    public boolean isProcessoAplicativoIdModified() {
        return aProcessoAplicativoId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo FORMULA_VALOR_ESPERADO_ID">
    
    public EntRegraVariavelPlanoExecucao formulaValorEsperadoId(Long value) {
        setFormulaValorEsperadoId(value);
        return this;
    }
    
    public void setFormulaValorEsperadoId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyFormulaValorEsperadoId();
        } else {
            aFormulaValorEsperadoId.setValue(value.getValue());
            if (aFormulaValorEsperadoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setFormulaValorEsperadoId(String value) {
        if (value == null) {
            nullifyFormulaValorEsperadoId();
        } else {
            aFormulaValorEsperadoId.setValue(value);
            if (aFormulaValorEsperadoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setFormulaValorEsperadoId(Long value) {
        aFormulaValorEsperadoId.setValue(value);
        if (aFormulaValorEsperadoId.isModified()) {
            setModified(true);
        }
    }
    
    public void setFormulaValorEsperadoId(Object value) {
        aFormulaValorEsperadoId.setValue(value);
        if (aFormulaValorEsperadoId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyFormulaValorEsperadoId() {
        if (!aFormulaValorEsperadoId.isNull()) {
            aFormulaValorEsperadoId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getFormulaValorEsperadoId() {
        return aFormulaValorEsperadoId;
    }
    
    public DomId oldFormulaValorEsperadoId() {
        return oFormulaValorEsperadoId;
    }
    
    public Long valueOfFormulaValorEsperadoId() {
        return aFormulaValorEsperadoId.getValue();
    }
    
    public boolean isFormulaValorEsperadoIdModified() {
        return aFormulaValorEsperadoId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo VALOR_DEFAULT">
    
    public EntRegraVariavelPlanoExecucao valorDefault(String value) {
        setValorDefault(value);
        return this;
    }
    
    public void setValorDefault(DomText value) {
        if (value == null || value.isNull()) {
            nullifyValorDefault();
        } else {
            aValorDefault.setValue(value.getValue());
            if (aValorDefault.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setValorDefault(String value) {
        if (value == null) {
            nullifyValorDefault();
        } else {
            aValorDefault.setValue(value);
            if (aValorDefault.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setValorDefault(Object value) {
        aValorDefault.setValue(value);
        if (aValorDefault.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyValorDefault() {
        if (!aValorDefault.isNull()) {
            aValorDefault.setNull(true);
            setModified(true);
        }
    }
    
    public DomText getValorDefault() {
        return aValorDefault;
    }
    
    public DomText oldValorDefault() {
        return oValorDefault;
    }
    
    public String valueOfValorDefault() {
        return aValorDefault.getValue();
    }
    
    public boolean isValorDefaultModified() {
        return aValorDefault.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo LISTA_VALORES">
    
    public EntRegraVariavelPlanoExecucao listaValores(String value) {
        setListaValores(value);
        return this;
    }
    
    public void setListaValores(DomProperties value) {
        if (value == null || value.isNull()) {
            nullifyListaValores();
        } else {
            aListaValores.setValue(value.getValue());
            if (aListaValores.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setListaValores(String value) {
        if (value == null) {
            nullifyListaValores();
        } else {
            aListaValores.setValue(value);
            if (aListaValores.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setListaValores(Object value) {
        aListaValores.setValue(value);
        if (aListaValores.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyListaValores() {
        if (!aListaValores.isNull()) {
            aListaValores.setNull(true);
            setModified(true);
        }
    }
    
    public DomProperties getListaValores() {
        return aListaValores;
    }
    
    public DomProperties oldListaValores() {
        return oListaValores;
    }
    
    public String valueOfListaValores() {
        return aListaValores.getValue();
    }
    
    public boolean isListaValoresModified() {
        return aListaValores.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo VALOR_MINIMO_ESPERADO">
    
    public EntRegraVariavelPlanoExecucao valorMinimoEsperado(String value) {
        setValorMinimoEsperado(value);
        return this;
    }
    
    public void setValorMinimoEsperado(DomText value) {
        if (value == null || value.isNull()) {
            nullifyValorMinimoEsperado();
        } else {
            aValorMinimoEsperado.setValue(value.getValue());
            if (aValorMinimoEsperado.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setValorMinimoEsperado(String value) {
        if (value == null) {
            nullifyValorMinimoEsperado();
        } else {
            aValorMinimoEsperado.setValue(value);
            if (aValorMinimoEsperado.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setValorMinimoEsperado(Object value) {
        aValorMinimoEsperado.setValue(value);
        if (aValorMinimoEsperado.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyValorMinimoEsperado() {
        if (!aValorMinimoEsperado.isNull()) {
            aValorMinimoEsperado.setNull(true);
            setModified(true);
        }
    }
    
    public DomText getValorMinimoEsperado() {
        return aValorMinimoEsperado;
    }
    
    public DomText oldValorMinimoEsperado() {
        return oValorMinimoEsperado;
    }
    
    public String valueOfValorMinimoEsperado() {
        return aValorMinimoEsperado.getValue();
    }
    
    public boolean isValorMinimoEsperadoModified() {
        return aValorMinimoEsperado.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo VALOR_MAXIMO_ESPERADO">
    
    public EntRegraVariavelPlanoExecucao valorMaximoEsperado(String value) {
        setValorMaximoEsperado(value);
        return this;
    }
    
    public void setValorMaximoEsperado(DomText value) {
        if (value == null || value.isNull()) {
            nullifyValorMaximoEsperado();
        } else {
            aValorMaximoEsperado.setValue(value.getValue());
            if (aValorMaximoEsperado.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setValorMaximoEsperado(String value) {
        if (value == null) {
            nullifyValorMaximoEsperado();
        } else {
            aValorMaximoEsperado.setValue(value);
            if (aValorMaximoEsperado.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setValorMaximoEsperado(Object value) {
        aValorMaximoEsperado.setValue(value);
        if (aValorMaximoEsperado.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyValorMaximoEsperado() {
        if (!aValorMaximoEsperado.isNull()) {
            aValorMaximoEsperado.setNull(true);
            setModified(true);
        }
    }
    
    public DomText getValorMaximoEsperado() {
        return aValorMaximoEsperado;
    }
    
    public DomText oldValorMaximoEsperado() {
        return oValorMaximoEsperado;
    }
    
    public String valueOfValorMaximoEsperado() {
        return aValorMaximoEsperado.getValue();
    }
    
    public boolean isValorMaximoEsperadoModified() {
        return aValorMaximoEsperado.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo FORMULA_VALOR_MINIMO_ID">
    
    public EntRegraVariavelPlanoExecucao formulaValorMinimoId(Long value) {
        setFormulaValorMinimoId(value);
        return this;
    }
    
    public void setFormulaValorMinimoId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyFormulaValorMinimoId();
        } else {
            aFormulaValorMinimoId.setValue(value.getValue());
            if (aFormulaValorMinimoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setFormulaValorMinimoId(String value) {
        if (value == null) {
            nullifyFormulaValorMinimoId();
        } else {
            aFormulaValorMinimoId.setValue(value);
            if (aFormulaValorMinimoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setFormulaValorMinimoId(Long value) {
        aFormulaValorMinimoId.setValue(value);
        if (aFormulaValorMinimoId.isModified()) {
            setModified(true);
        }
    }
    
    public void setFormulaValorMinimoId(Object value) {
        aFormulaValorMinimoId.setValue(value);
        if (aFormulaValorMinimoId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyFormulaValorMinimoId() {
        if (!aFormulaValorMinimoId.isNull()) {
            aFormulaValorMinimoId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getFormulaValorMinimoId() {
        return aFormulaValorMinimoId;
    }
    
    public DomId oldFormulaValorMinimoId() {
        return oFormulaValorMinimoId;
    }
    
    public Long valueOfFormulaValorMinimoId() {
        return aFormulaValorMinimoId.getValue();
    }
    
    public boolean isFormulaValorMinimoIdModified() {
        return aFormulaValorMinimoId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo FORMULA_VALOR_MAXIMO_ID">
    
    public EntRegraVariavelPlanoExecucao formulaValorMaximoId(Long value) {
        setFormulaValorMaximoId(value);
        return this;
    }
    
    public void setFormulaValorMaximoId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyFormulaValorMaximoId();
        } else {
            aFormulaValorMaximoId.setValue(value.getValue());
            if (aFormulaValorMaximoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setFormulaValorMaximoId(String value) {
        if (value == null) {
            nullifyFormulaValorMaximoId();
        } else {
            aFormulaValorMaximoId.setValue(value);
            if (aFormulaValorMaximoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setFormulaValorMaximoId(Long value) {
        aFormulaValorMaximoId.setValue(value);
        if (aFormulaValorMaximoId.isModified()) {
            setModified(true);
        }
    }
    
    public void setFormulaValorMaximoId(Object value) {
        aFormulaValorMaximoId.setValue(value);
        if (aFormulaValorMaximoId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyFormulaValorMaximoId() {
        if (!aFormulaValorMaximoId.isNull()) {
            aFormulaValorMaximoId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getFormulaValorMaximoId() {
        return aFormulaValorMaximoId;
    }
    
    public DomId oldFormulaValorMaximoId() {
        return oFormulaValorMaximoId;
    }
    
    public Long valueOfFormulaValorMaximoId() {
        return aFormulaValorMaximoId.getValue();
    }
    
    public boolean isFormulaValorMaximoIdModified() {
        return aFormulaValorMaximoId.isModified();
    }
    // </editor-fold>
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="getErrors">
    /**
     * Traduz um erro recebido do banco de dados para um AdsException
     */
    @Override
    public AdsException getErrors(String errorMsg, int transaction) {
        AdsException e;
        String msg = errorMsg.toUpperCase();
        
        if (transaction == DELETE_TRANSACTION) {
            e = new AdsException("ZTEST.REGRA_VARIAVEL_PLANO_EXECUCAO.GET_ERRORS_UNKNOWN",
                    AdsException.UNKNOWN,
                    "Erro não esperado: " + errorMsg);
        } else {
            if (msg.indexOf("UK_RGVVPE_PLANO_VAR_PROCESS") >= 0) {
                e = new AdsException("ZTEST.REGRA_VARIAVEL_PLANO_EXECUCAO.UK_RGVVPE_PLANO_VAR_PROCESS", 
                        Severity.ERROR,
                        "Registro duplicado! Plano, variável, processo/etapa do aplicativo, ponto de execução e número da iteração devem ser únicos Plano de execução ${PLANO_EXECUCAO_ID}, Variável do aplicativo ${VARIAVEL_APLICATIVO_ID}, Processo do aplicativo ${PROCESSO_APLICATIVO_ID}, Ponto do plano de execução ${PONTO_PLANO_EXECUCAO_ID}, Número da iteração ${NUMERO_ITERACAO} (UK_RGVVPE_PLANO_VAR_PROCESS)");
                return e;
            } else if (msg.indexOf("FK_RGVVPE_FORMULA_MAXIMO_ESPERADO") >= 0) {
                e = new AdsException("ZTEST.REGRA_VARIAVEL_PLANO_EXECUCAO.FK_RGVVPE_FORMULA_MAXIMO_ESPERADO", 
                        Severity.ERROR,
                        "Registro não cadastrado para FORMULA_VALOR_MAXIMO! (FK_RGVVPE_FORMULA_MAXIMO_ESPERADO)");
                return e;
            } else if (msg.indexOf("FK_RGVVPE_FORMULA_MINIMO_ESPERADO") >= 0) {
                e = new AdsException("ZTEST.REGRA_VARIAVEL_PLANO_EXECUCAO.FK_RGVVPE_FORMULA_MINIMO_ESPERADO", 
                        Severity.ERROR,
                        "Registro não cadastrado para FORMULA_VALOR_MINIMO! (FK_RGVVPE_FORMULA_MINIMO_ESPERADO)");
                return e;
            } else if (msg.indexOf("FK_RGVVPE_FORMULA_VALOR") >= 0) {
                e = new AdsException("ZTEST.REGRA_VARIAVEL_PLANO_EXECUCAO.FK_RGVVPE_FORMULA_VALOR", 
                        Severity.ERROR,
                        "Registro não cadastrado para FORMULA_VALOR_ESPERADO! (FK_RGVVPE_FORMULA_VALOR)");
                return e;
            } else if (msg.indexOf("PK_RGVVPE") >= 0) {
                e = new AdsException("ZTEST.REGRA_VARIAVEL_PLANO_EXECUCAO.PK_RGVVPE", 
                        Severity.ERROR,
                        "ID duplicado! (PK_RGVVPE)");
                return e;
            } else if (msg.indexOf("FK_RGVVPE_PLANO_EXECUCAO") >= 0) {
                e = new AdsException("ZTEST.REGRA_VARIAVEL_PLANO_EXECUCAO.FK_RGVVPE_PLANO_EXECUCAO", 
                        Severity.ERROR,
                        "Registro não cadastrado para PLANO_EXECUCAO! (FK_RGVVPE_PLANO_EXECUCAO)");
                return e;
            } else if (msg.indexOf("FK_RGVVPE_VARIAVEL_APLICATIVO") >= 0) {
                e = new AdsException("ZTEST.REGRA_VARIAVEL_PLANO_EXECUCAO.FK_RGVVPE_VARIAVEL_APLICATIVO", 
                        Severity.ERROR,
                        "Registro não cadastrado para VARIAVEL_APLICATIVO! (FK_RGVVPE_VARIAVEL_APLICATIVO)");
                return e;
            } else if (msg.indexOf("FK_RGVVPE_PONTO_PLANO_EXECUCAO") >= 0) {
                e = new AdsException("ZTEST.REGRA_VARIAVEL_PLANO_EXECUCAO.FK_RGVVPE_PONTO_PLANO_EXECUCAO", 
                        Severity.ERROR,
                        "Registro não cadastrado para PONTO_PLANO_EXECUCAO! (FK_RGVVPE_PONTO_PLANO_EXECUCAO)");
                return e;
            } else if (msg.indexOf("FK_RGVVPE_PROCESSO_APLICATIVO") >= 0) {
                e = new AdsException("ZTEST.REGRA_VARIAVEL_PLANO_EXECUCAO.FK_RGVVPE_PROCESSO_APLICATIVO", 
                        Severity.ERROR,
                        "Registro não cadastrado para PROCESSO_APLICATIVO! (FK_RGVVPE_PROCESSO_APLICATIVO)");
                return e;
            } else {
                e = new AdsException("ZTEST.REGRA_VARIAVEL_PLANO_EXECUCAO.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        }
        return e;
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Entity Information">
    
    public String getEntityName() {
        return ENTITY_NAME;
    }
    
    public String getTableName() {
        return TABLE_NAME;
    }
    
    public String idSequenceName() {
        return "PK_SEQUENCE";
    }
    
    private ArrayList<Field> allAttributes;
    public ArrayList<Field> getAllAttributes() {
        if (allAttributes == null) {
            allAttributes = new ArrayList<Field>();
            allAttributes.add(aId);
            allAttributes.add(aVariavelAplicativoId);
            allAttributes.add(aPlanoExecucaoId);
            allAttributes.add(aPontoPlanoExecucaoId);
            allAttributes.add(aNumeroIteracao);
            allAttributes.add(aProcessoAplicativoId);
            allAttributes.add(aFormulaValorEsperadoId);
            allAttributes.add(aValorDefault);
            allAttributes.add(aListaValores);
            allAttributes.add(aValorMinimoEsperado);
            allAttributes.add(aValorMaximoEsperado);
            allAttributes.add(aFormulaValorMinimoId);
            allAttributes.add(aFormulaValorMaximoId);
        }
        return allAttributes;
    }
    
    /**
     * Retorna o valor da primeira UK da entidade
     * Se ela for composta, retorna a concatenação de toda a combinação
     * de atributos separados por um espaço.
     */
    public String valueOfUk() {
        return getPlanoExecucaoId().toString() +
                " " + getVariavelAplicativoId().toString() +
                " " + getProcessoAplicativoId().toString() +
                " " + getPontoPlanoExecucaoId().toString() +
                " " + getNumeroIteracao().toString();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Relationships">
    
    
    public void findByPlanoExecucaoIdVariavelAplicativoIdProcessoAplicativoIdPontoPlanoExecucaoIdNumeroIteracao(long planoExecucaoId, long variavelAplicativoId, long processoAplicativoId, long pontoPlanoExecucaoId, int numeroIteracao) throws AdsException {
        findBy(new String[] {"PLANO_EXECUCAO_ID", "VARIAVEL_APLICATIVO_ID", "PROCESSO_APLICATIVO_ID", "PONTO_PLANO_EXECUCAO_ID", "NUMERO_ITERACAO"},
                new Object[] {planoExecucaoId, variavelAplicativoId, processoAplicativoId, pontoPlanoExecucaoId, numeroIteracao});
    }
    
    private EntFormulaExecucao eFormulaValorMaximo;
    
    public EntFormulaExecucao findFormulaValorMaximo() throws AdsException {
        if (getFormulaValorMaximoId().isNull()) {
            return null;
        }
        if (eFormulaValorMaximo == null || !valueOfFormulaValorMaximoId().equals(eFormulaValorMaximo.valueOfId())) {
            eFormulaValorMaximo = new EntFormulaExecucao(ctx);
            eFormulaValorMaximo.find(valueOfFormulaValorMaximoId());
        }
        return eFormulaValorMaximo;
    }
    
    /**
     * Ativa o join desta entidade com FORMULA_EXECUCAO
     * através do atributo FORMULA_VALOR_MAXIMO_ID
     */
    public EntFormulaExecucao joinFormulaValorMaximo() {
        return joinFormulaValorMaximo(null);
    }
    public EntFormulaExecucao joinFormulaValorMaximo(String alias) {
        EntFormulaExecucao entity = new EntFormulaExecucao(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getFormulaValorMaximoId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByFormulaValorMaximo(long id, String sqlAppend) throws AdsException {
        find("select ID from REGRA_VARIAVEL_PLANO_EXECUCAO where FORMULA_VALOR_MAXIMO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByFormulaValorMaximo(long id) throws AdsException {
        findByFormulaValorMaximo(id,"");
    }
    
    public void findByFormulaValorMaximo(Entity entidade) throws AdsException {
        findByFormulaValorMaximo(entidade.valueOfId(),"");
    }
    
    public void findByFormulaValorMaximo(Entity entidade, String sqlAppend) throws AdsException {
        findByFormulaValorMaximo(entidade.valueOfId(),sqlAppend);
    }
    
    private EntFormulaExecucao eFormulaValorMinimo;
    
    public EntFormulaExecucao findFormulaValorMinimo() throws AdsException {
        if (getFormulaValorMinimoId().isNull()) {
            return null;
        }
        if (eFormulaValorMinimo == null || !valueOfFormulaValorMinimoId().equals(eFormulaValorMinimo.valueOfId())) {
            eFormulaValorMinimo = new EntFormulaExecucao(ctx);
            eFormulaValorMinimo.find(valueOfFormulaValorMinimoId());
        }
        return eFormulaValorMinimo;
    }
    
    /**
     * Ativa o join desta entidade com FORMULA_EXECUCAO
     * através do atributo FORMULA_VALOR_MINIMO_ID
     */
    public EntFormulaExecucao joinFormulaValorMinimo() {
        return joinFormulaValorMinimo(null);
    }
    public EntFormulaExecucao joinFormulaValorMinimo(String alias) {
        EntFormulaExecucao entity = new EntFormulaExecucao(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getFormulaValorMinimoId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByFormulaValorMinimo(long id, String sqlAppend) throws AdsException {
        find("select ID from REGRA_VARIAVEL_PLANO_EXECUCAO where FORMULA_VALOR_MINIMO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByFormulaValorMinimo(long id) throws AdsException {
        findByFormulaValorMinimo(id,"");
    }
    
    public void findByFormulaValorMinimo(Entity entidade) throws AdsException {
        findByFormulaValorMinimo(entidade.valueOfId(),"");
    }
    
    public void findByFormulaValorMinimo(Entity entidade, String sqlAppend) throws AdsException {
        findByFormulaValorMinimo(entidade.valueOfId(),sqlAppend);
    }
    
    private EntFormulaExecucao eFormulaValorEsperado;
    
    public EntFormulaExecucao findFormulaValorEsperado() throws AdsException {
        if (getFormulaValorEsperadoId().isNull()) {
            return null;
        }
        if (eFormulaValorEsperado == null || !valueOfFormulaValorEsperadoId().equals(eFormulaValorEsperado.valueOfId())) {
            eFormulaValorEsperado = new EntFormulaExecucao(ctx);
            eFormulaValorEsperado.find(valueOfFormulaValorEsperadoId());
        }
        return eFormulaValorEsperado;
    }
    
    /**
     * Ativa o join desta entidade com FORMULA_EXECUCAO
     * através do atributo FORMULA_VALOR_ESPERADO_ID
     */
    public EntFormulaExecucao joinFormulaValorEsperado() {
        return joinFormulaValorEsperado(null);
    }
    public EntFormulaExecucao joinFormulaValorEsperado(String alias) {
        EntFormulaExecucao entity = new EntFormulaExecucao(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getFormulaValorEsperadoId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByFormulaValorEsperado(long id, String sqlAppend) throws AdsException {
        find("select ID from REGRA_VARIAVEL_PLANO_EXECUCAO where FORMULA_VALOR_ESPERADO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByFormulaValorEsperado(long id) throws AdsException {
        findByFormulaValorEsperado(id,"");
    }
    
    public void findByFormulaValorEsperado(Entity entidade) throws AdsException {
        findByFormulaValorEsperado(entidade.valueOfId(),"");
    }
    
    public void findByFormulaValorEsperado(Entity entidade, String sqlAppend) throws AdsException {
        findByFormulaValorEsperado(entidade.valueOfId(),sqlAppend);
    }
    
    private EntPlanoExecucao ePlanoExecucao;
    
    public EntPlanoExecucao findPlanoExecucao() throws AdsException {
        if (getPlanoExecucaoId().isNull()) {
            return null;
        }
        if (ePlanoExecucao == null || !valueOfPlanoExecucaoId().equals(ePlanoExecucao.valueOfId())) {
            ePlanoExecucao = new EntPlanoExecucao(ctx);
            ePlanoExecucao.find(valueOfPlanoExecucaoId());
        }
        return ePlanoExecucao;
    }
    
    /**
     * Ativa o join desta entidade com PLANO_EXECUCAO
     * através do atributo PLANO_EXECUCAO_ID
     */
    public EntPlanoExecucao joinPlanoExecucao() {
        return joinPlanoExecucao(null);
    }
    public EntPlanoExecucao joinPlanoExecucao(String alias) {
        EntPlanoExecucao entity = new EntPlanoExecucao(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getPlanoExecucaoId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByPlanoExecucao(long id, String sqlAppend) throws AdsException {
        find("select ID from REGRA_VARIAVEL_PLANO_EXECUCAO where PLANO_EXECUCAO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByPlanoExecucao(long id) throws AdsException {
        findByPlanoExecucao(id,"");
    }
    
    public void findByPlanoExecucao(Entity entidade) throws AdsException {
        findByPlanoExecucao(entidade.valueOfId(),"");
    }
    
    public void findByPlanoExecucao(Entity entidade, String sqlAppend) throws AdsException {
        findByPlanoExecucao(entidade.valueOfId(),sqlAppend);
    }
    
    private EntVariavelAplicativo eVariavelAplicativo;
    
    public EntVariavelAplicativo findVariavelAplicativo() throws AdsException {
        if (getVariavelAplicativoId().isNull()) {
            return null;
        }
        if (eVariavelAplicativo == null || !valueOfVariavelAplicativoId().equals(eVariavelAplicativo.valueOfId())) {
            eVariavelAplicativo = new EntVariavelAplicativo(ctx);
            eVariavelAplicativo.find(valueOfVariavelAplicativoId());
        }
        return eVariavelAplicativo;
    }
    
    /**
     * Ativa o join desta entidade com VARIAVEL_APLICATIVO
     * através do atributo VARIAVEL_APLICATIVO_ID
     */
    public EntVariavelAplicativo joinVariavelAplicativo() {
        return joinVariavelAplicativo(null);
    }
    public EntVariavelAplicativo joinVariavelAplicativo(String alias) {
        EntVariavelAplicativo entity = new EntVariavelAplicativo(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getVariavelAplicativoId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByVariavelAplicativo(long id, String sqlAppend) throws AdsException {
        find("select ID from REGRA_VARIAVEL_PLANO_EXECUCAO where VARIAVEL_APLICATIVO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByVariavelAplicativo(long id) throws AdsException {
        findByVariavelAplicativo(id,"");
    }
    
    public void findByVariavelAplicativo(Entity entidade) throws AdsException {
        findByVariavelAplicativo(entidade.valueOfId(),"");
    }
    
    public void findByVariavelAplicativo(Entity entidade, String sqlAppend) throws AdsException {
        findByVariavelAplicativo(entidade.valueOfId(),sqlAppend);
    }
    
    private EntPontoPlanoExecucao ePontoPlanoExecucao;
    
    public EntPontoPlanoExecucao findPontoPlanoExecucao() throws AdsException {
        if (getPontoPlanoExecucaoId().isNull()) {
            return null;
        }
        if (ePontoPlanoExecucao == null || !valueOfPontoPlanoExecucaoId().equals(ePontoPlanoExecucao.valueOfId())) {
            ePontoPlanoExecucao = new EntPontoPlanoExecucao(ctx);
            ePontoPlanoExecucao.find(valueOfPontoPlanoExecucaoId());
        }
        return ePontoPlanoExecucao;
    }
    
    /**
     * Ativa o join desta entidade com PONTO_PLANO_EXECUCAO
     * através do atributo PONTO_PLANO_EXECUCAO_ID
     */
    public EntPontoPlanoExecucao joinPontoPlanoExecucao() {
        return joinPontoPlanoExecucao(null);
    }
    public EntPontoPlanoExecucao joinPontoPlanoExecucao(String alias) {
        EntPontoPlanoExecucao entity = new EntPontoPlanoExecucao(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getPontoPlanoExecucaoId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByPontoPlanoExecucao(long id, String sqlAppend) throws AdsException {
        find("select ID from REGRA_VARIAVEL_PLANO_EXECUCAO where PONTO_PLANO_EXECUCAO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByPontoPlanoExecucao(long id) throws AdsException {
        findByPontoPlanoExecucao(id,"");
    }
    
    public void findByPontoPlanoExecucao(Entity entidade) throws AdsException {
        findByPontoPlanoExecucao(entidade.valueOfId(),"");
    }
    
    public void findByPontoPlanoExecucao(Entity entidade, String sqlAppend) throws AdsException {
        findByPontoPlanoExecucao(entidade.valueOfId(),sqlAppend);
    }
    
    private EntProcessoAplicativo eProcessoAplicativo;
    
    public EntProcessoAplicativo findProcessoAplicativo() throws AdsException {
        if (getProcessoAplicativoId().isNull()) {
            return null;
        }
        if (eProcessoAplicativo == null || !valueOfProcessoAplicativoId().equals(eProcessoAplicativo.valueOfId())) {
            eProcessoAplicativo = new EntProcessoAplicativo(ctx);
            eProcessoAplicativo.find(valueOfProcessoAplicativoId());
        }
        return eProcessoAplicativo;
    }
    
    /**
     * Ativa o join desta entidade com PROCESSO_APLICATIVO
     * através do atributo PROCESSO_APLICATIVO_ID
     */
    public EntProcessoAplicativo joinProcessoAplicativo() {
        return joinProcessoAplicativo(null);
    }
    public EntProcessoAplicativo joinProcessoAplicativo(String alias) {
        EntProcessoAplicativo entity = new EntProcessoAplicativo(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getProcessoAplicativoId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByProcessoAplicativo(long id, String sqlAppend) throws AdsException {
        find("select ID from REGRA_VARIAVEL_PLANO_EXECUCAO where PROCESSO_APLICATIVO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByProcessoAplicativo(long id) throws AdsException {
        findByProcessoAplicativo(id,"");
    }
    
    public void findByProcessoAplicativo(Entity entidade) throws AdsException {
        findByProcessoAplicativo(entidade.valueOfId(),"");
    }
    
    public void findByProcessoAplicativo(Entity entidade, String sqlAppend) throws AdsException {
        findByProcessoAplicativo(entidade.valueOfId(),sqlAppend);
    }
    
    /**
     * Limpa os objetos normalizados da entidade
     */
    public void clearRelatedObjects() {
        eFormulaValorMaximo = null;
        eFormulaValorMinimo = null;
        eFormulaValorEsperado = null;
        ePlanoExecucao = null;
        eVariavelAplicativo = null;
        ePontoPlanoExecucao = null;
        eProcessoAplicativo = null;
    }
    
    /**
     * Método que copia os valores dos atributos
     * para os valores respectivos old 
     */
    public void saveOldAtributes() {
        oFormulaValorEsperadoId.setValue(aFormulaValorEsperadoId);
        oFormulaValorMaximoId.setValue(aFormulaValorMaximoId);
        oFormulaValorMinimoId.setValue(aFormulaValorMinimoId);
        oValorMaximoEsperado.setValue(aValorMaximoEsperado);
        oValorMinimoEsperado.setValue(aValorMinimoEsperado);
        oListaValores.setValue(aListaValores);
        oValorDefault.setValue(aValorDefault);
        oId.setValue(aId);
        oVariavelAplicativoId.setValue(aVariavelAplicativoId);
        oPlanoExecucaoId.setValue(aPlanoExecucaoId);
        oPontoPlanoExecucaoId.setValue(aPontoPlanoExecucaoId);
        oNumeroIteracao.setValue(aNumeroIteracao);
        oProcessoAplicativoId.setValue(aProcessoAplicativoId);
    }
    
    /**
     * Método que retorna as regras da entidade
     * @return ArrayList com as regras ou null caso não existir nenhuma regra
     */
    public ArrayList getAllRules() {
        ArrayList<EntityRule> out = new ArrayList<EntityRule>();
        {
            PrimaryKeyRule rule = new PrimaryKeyRule();
            rule.setEntity(EntRegraVariavelPlanoExecucao.class);
            rule.setName("PK_RGVVPE");
            rule.setPkAttribute(new DomId("ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntRegraVariavelPlanoExecucao.class);
            rule.setAssociatedEntity(EntFormulaExecucao.class);
            rule.setName("FK_RGVVPE_FORMULA_MAXIMO_ESPERADO");
            rule.addAttribute(new DomId("FORMULA_VALOR_MAXIMO_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntRegraVariavelPlanoExecucao.class);
            rule.setAssociatedEntity(EntFormulaExecucao.class);
            rule.setName("FK_RGVVPE_FORMULA_MINIMO_ESPERADO");
            rule.addAttribute(new DomId("FORMULA_VALOR_MINIMO_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntRegraVariavelPlanoExecucao.class);
            rule.setAssociatedEntity(EntFormulaExecucao.class);
            rule.setName("FK_RGVVPE_FORMULA_VALOR");
            rule.addAttribute(new DomId("FORMULA_VALOR_ESPERADO_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntRegraVariavelPlanoExecucao.class);
            rule.setAssociatedEntity(EntPlanoExecucao.class);
            rule.setName("FK_RGVVPE_PLANO_EXECUCAO");
            rule.addAttribute(new DomId("PLANO_EXECUCAO_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntRegraVariavelPlanoExecucao.class);
            rule.setAssociatedEntity(EntPontoPlanoExecucao.class);
            rule.setName("FK_RGVVPE_PONTO_PLANO_EXECUCAO");
            rule.addAttribute(new DomId("PONTO_PLANO_EXECUCAO_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntRegraVariavelPlanoExecucao.class);
            rule.setAssociatedEntity(EntProcessoAplicativo.class);
            rule.setName("FK_RGVVPE_PROCESSO_APLICATIVO");
            rule.addAttribute(new DomId("PROCESSO_APLICATIVO_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntRegraVariavelPlanoExecucao.class);
            rule.setAssociatedEntity(EntVariavelAplicativo.class);
            rule.setName("FK_RGVVPE_VARIAVEL_APLICATIVO");
            rule.addAttribute(new DomId("VARIAVEL_APLICATIVO_ID",""));
            out.add(rule);
        }
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntRegraVariavelPlanoExecucao.class);
            rule.setName("UK_RGVVPE_PLANO_VAR_PROCESS");
            rule.addAttribute(new DomId("PLANO_EXECUCAO_ID",""));
            rule.addAttribute(new DomId("VARIAVEL_APLICATIVO_ID",""));
            rule.addAttribute(new DomId("PROCESSO_APLICATIVO_ID",""));
            rule.addAttribute(new DomId("PONTO_PLANO_EXECUCAO_ID",""));
            rule.addAttribute(new DomInteger("NUMERO_ITERACAO",""));
            out.add(rule);
        }
        return out;
    }
    // </editor-fold>
    
    @Override
    public void fillDefaultValues() throws AdsException {
        if (aId.isNull()) {
            aId.setValue("" + ctx.getNextVal("pk_sequence"));
        }
        if (getNumeroIteracao().isNull()) {
            setNumeroIteracao(getNumeroIteracao().getDefaultValue());
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="Métodos customizados">
}
